multi-platform solutions

cpp

share cpp code with Android and iOS

Wechat | Tencent Drive

J2ObjC

Translate Java code to OC

Multi-OS Engine

Bundle an ART VM into iOS app

R/N & Weex & Xarmain

Language + Binding

Flutter

Language + Framework

to sum up

Kotlin/Native runtime

• memory management
• object memory layout
• concurrency model
• virtual method call

memory management

ARC with cycle collector

automated reference counter with a cycle collector to collect cyclical garbage.

C/C++	OC/Swift	Java	K/N
manual	half-auto	auto	auto

concurrency model

1. can't share mutable object across threads
2. freeze() marks an object tree inmmutable, thus sharing across threads
3. DetachedObjectGraph to transfer ownership to other thread, thus mutable.

Still under constructing...
coroutint isn't truly concurrent, yet

Official doc

interop with OC/Swift

1. K/N call OC methods

2. K/N extends OC class (and/or impl oc protocol)

3. passing K/N reference to OC

4. and vice versa

5. withiout performance penalty

Official Document

K/N Swit interop -- method

kotlin

NSRunLoop.mainRunLoop().performBlock { block.run() }

swift

presenter = StoryContentPresenter(storyId: detailStory.id)
presenter.onLoadData = { [unowned self] data in
    self.renderData(data)
    return KotlinUnit()
}

OC

SharedCodeStoryContentPresenter *presenter = 
    [[SharedCodeStoryContentPresenter: alloc] initWithStoryId: story.id]]

K/N Swift interop -- passing ref

// create a kotlin instance
let block = LinkedList.Companion().createACallable()
block(KotlinInt.init(value: 42)) // and use it

All kotlin class inherits KotlinBase which inherits NSObject

let list = LinkedList() // kotlin class
list.put(e: Junk()) // Junk is swift class

OC class must inhert from NSObject to pass to kotlin

K/N Swift interop -- class

kotlin extends OC class

@ExportObjCClass
class ViewController : UIViewController {
    @OverrideInit constructor(coder: NSCoder) : super(coder)
    @ObjCOutlet lateinit var button: UIButton
    @ObjCAction fun buttonPressed() {
        label.text = "Konan says: 'Hello, ${textField.text}!'"
    }
}

swift extends Kotlin class

open class AKotlinClass {
    open fun helloWorld(greet: String) { ... }
}

class SwiftClassInheritedFromKotlinClass : AKotlinClass {
    override func helloWorld(greet: String) { ... }
}

K/N Swit interop -- import K/N to OC

1. K/N compiles to standard OC framework

2. import framework into OC/Swift

K/N Swit interop -- import OC to K/N

cinterop to the rescue

// UIKit.def
depends = CFNetwork ...
language = Objective-C
package = platform.UIKit
headers = UIKit/UIKit.h
linkerOpts = -framework UIKit
...

cinterop create Kotlin binding for C and OC/Swift

K/N Swift interop -- iOS framework

K/N has already defined cinterop definition files

And you can write your own cinterop definition file, which is easy

expect & actual

SharedCode
└── src
    ├── androidMain
    │   └── actuals.kt
    ├── commonMain
    │   └── expects.kt
    └── iOSMain
        └── actuals.kt

Seperate implementation and declaration

Similar to interface, but differs!

function expect-actual

commmon-exepcts

expect suspend fun httpGet(url: String): String

anriod-actual

actual suspend fun httpGet(url: String): String = withContext(MyDispatchers.Worker) {
    val httpConn = URL(url).openConnection() as HttpURLConnection
    httpConn.connect()
    httpConn.inputStream.readBytes().toString(Charsets.UTF_8)
    // ...
}

ios-actual

actual suspend fun httpGet(url: String): String {
    val request = NSMutableURLRequest()
    request.setHTTPMethod("GET")
    request.setURL(NSURL(string = url))
    // ...
}

class expect-actual

commmon-exepcts

expect object MyDispatchers {
    val Main: CoroutineDispatcher
}

anriod-actual

actual object MyDispatchers {
    actual val Main: CoroutineDispatcher = Dispatchers.Main
}

ios-actual

actual object MyDispatchers {
    actual val Main: CoroutineDispatcher = object : CoroutineDispatcher() {
        override fun dispatch(context: CoroutineContext, block: Runnable) {
            NSRunLoop.mainRunLoop().performBlock { block.run() } } }
}

expect-actual vs interface

1. both need common decliration
2. both need different implmentation
3. expect-actual is static
4. interface is dynamic
5. expect-actual don't need depedency injection